package hu.vissy.utils;

import java.util.Arrays;

public class MathUtils {


//    /** Ln(2) konstans. */
//    public static final double LN2 = Math.log(2);
//
//    /**
//     * Ket double ertek kozotti minimalis elteres, ami alatt egyenlonek
//     * szamitanak
//     */
//    public static final double EPSILON;
//
//
//
//
//    // NOTE jozansagi megfontolasok
//    static {
//        EPSILON = System.getProperty("epsilon") == null ? Math.pow(10, -3) : Double.parseDouble(System.getProperty("epsilon"));
//
//        if (EPSILON <= 0) {
//            throw new IllegalArgumentException("epsilon property value is [" + EPSILON + "], it must be > 0.");
//        }
//    }
//
    private MathUtils() {
    }

//
//
//    /**
//     * Ket double ertek tavolsaganak >= 1 egesz szamu hatvanya
//     *
//     * @param a
//     *            az egyik double ertek
//     * @param b
//     *            a masik double ertek
//     * @param h
//     *            a hatvanykitevo, >= 1
//     * @return a ket ertek kozotti tavolsag, a megadott egesz hatvanyra emelve
//     */
//    public static final double differencePoweredToInt(double a, double b, int h) {
//        if (h < 1) {
//            throw new IllegalArgumentException("powered to value is [" + h + "], it must be >= 1");
//        }
//
//        if (h == 1) {
//            return Math.abs(a - b);
//        } else {
//            double dif = Math.abs(a - b);
//            if (h == 2) {
//                return dif * dif;
//            } else {
//                double pow = dif * dif;
//                for (int k = 2; k < h; k++) {
//                    pow *= dif;
//                }
//                return pow;
//                //return Math.pow(dif, h);
//            }
//        }
//    }
//
//
//    /**
//     * Kettes alapu logaritmust szamol.
//     *
//     * @param v
//     *            az ertek, aminek a logaritmusa szamolando
//     * @return a bemeneti ertek kettes alapu logaritmusa
//     */
//    public static final double log2(double v) {
//        return Math.log(v) / LN2;
//    }
//
//
//
//    /**
//     * Egy egesz erteket egy zart intervallum koze szorit.
//     *
//     * Amennyiben min > max az intervallum megforditasra kerul.
//     *
//     * @param value
//     *            A vizsgalt ertek.
//     * @param min
//     *            A megengedett minimum ertek.
//     * @param max
//     *            A megengedett maximum ertek.
//     * @return A vizsgalt ertekhez legkozelebbi ertek, amely a megadott
//     *         intervallumba esik.
//     */
//    public static final int bound(int value, int min, int max) {
//        if (min > max) {
//            int tmp = min;
//            min = max;
//            max = tmp;
//        }
//        if (value < min) {
//            return min;
//        }
//        if (value > max) {
//            return max;
//        }
//        return value;
//    }
//
//    /**
//     * Egy double erteket egy zart intervallum koze szorit.
//     *
//     * Amennyiben min > max az intervallum megforditasra kerul.
//     *
//     * @param value
//     *            A vizsgalt ertek.
//     * @param min
//     *            A megengedett minimum ertek.
//     * @param max
//     *            A megengedett maximum ertek.
//     * @return A vizsgalt ertekhez legkozelebbi ertek, amely a megadott
//     *         intervallumba esik.
//     */
//    public static final double bound(double value, double min, double max) {
//        if (min > max) {
//            double tmp = min;
//            min = max;
//            max = tmp;
//        }
//        if (value < min) {
//            return min;
//        }
//        if (value > max) {
//            return max;
//        }
//        return value;
//    }


    /**
     * Egész értékű, véletlenszám-generátor [0 és <i>threshold</i>-1]
     * értékkészleten.
     *
     * @param threshold
     *            Az értékkészlet felső határa.
     * @return A generált véletlen szám.
     */
    public static int random(int threshold) {
        return (int) (Math.random() * threshold);
    }


    /**
     * Kártyaleosztás generátor.
     *
     * @param cards
     *            A kártyák száma.
     * @param dealCount
     *            A leosztandó kártyák száma.
     * @return Egy <i>dealCount</i> elemszámú tömb a leosztott kártyák számával.
     */
    public static int[] deal(int cards, int dealCount) {

        if (cards < 0) {
            throw new IllegalArgumentException("Illegal card count.");
        }
        if (dealCount < 0) {
            throw new IllegalArgumentException("Illegal deal count.");
        }

        if (cards < dealCount) {
            throw new IllegalArgumentException("More deal than cards.");
        }

        int[] filled = new int[cards];
        int[] hand = new int[dealCount];

        for (int i = 0; i < cards; i++) {
            filled[i] = i;
        }

        int cnt = 0;
        while (dealCount > 0) {
            int r = random(cards);
            hand[cnt++] = filled[r];
            filled[r] = filled[cards - 1];
            filled[cards - 1] = -1;
            dealCount--;
            cards--;
        }

        Arrays.sort(hand);

        return hand;
    }

}
